home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / editors / mutt / me2s_pl7.zoo / mu_edit2 / ed / keytable.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-05  |  2.8 KB  |  95 lines
  1. static char rcsid[] = "$Id: keytable.c,v 1.1 1992/09/14 13:02:14 mike Exp $";
  2.  
  3. /* $Log: keytable.c,v $
  4.  * Revision 1.1  1992/09/14  13:02:14  mike
  5.  * Initial revision
  6.  *
  7.  */
  8.  
  9. /* keytable.c : deal with KeyTables.
  10.  * A KeyTable is a dTable of Keys.  Like so:
  11.  *   typedef struct { KeyCode <keyname>; <other key stuff>; } Key;
  12.  *   typedef declare_dTable_of(Key) KeyTable;
  13.  *   (you can use your own names - it don't matter to this code).
  14.  * It is real important that a KeyCode is the first element of a Key.
  15.  * C Durland
  16.  */
  17.  
  18. /* Copyright 1990, 1991 Craig Durland
  19.  *   Distributed under the terms of the GNU General Public License.
  20.  *   Distributed "as is", without warranties of any kind, but comments,
  21.  *     suggestions and bug reports are welcome.
  22.  */
  23.  
  24. #include <dtable.h>
  25. #include <const.h>
  26. #include "ed.h"
  27.  
  28. char *Efind_key(kt,keycode) dTable *kt; register KeyCode keycode;
  29. {
  30.   register char *key;
  31.   register int n, keysize;
  32.  
  33.   key = kt->table; n = sizeof_dTable(kt); keysize = kt->blob_size;
  34.   for (; n--; key += keysize) if (*(KeyCode *)key==keycode) return key;
  35.   return NULL;
  36. }
  37.  
  38.     /* Allocate a key in the keytable.  Reuse key if keycode already in the
  39.      *   table.
  40.      * Returns:
  41.      *   ptr to key that needs to be filled in.
  42.      *   NULL: no memory
  43.      */
  44. char *Ekalloc(kt,kc) dTable *kt; KeyCode kc;
  45. {
  46.   register char *key;
  47.  
  48.   if (!(key = Efind_key(kt,kc)))
  49.   {            /* key don't exist, make room in table */
  50.     if (!xpand_dTable(kt,1,10,10)) return NULL;
  51.     key = &kt->table[(sizeof_dTable(kt) -1)*kt->blob_size];
  52.   }
  53.   return key;
  54. }
  55.  
  56.     /* Pack a keytable.  remove_key() is called with a pointer to a key.  If
  57.      *   TRUE is returned, the key is taken out of the table.
  58.      * Assume:  Not many keys will be removed from key table.
  59.      * Note:
  60.      *   This routine could be made a lot faster with this alg:
  61.      *    walk till dead key
  62.      *   1: ptr = dead
  63.      *    walk while dead key
  64.      *    qtr = dead +1
  65.      *    walk till dead key
  66.      *    blkmov(ptr,qtr,dead-qtr)    ; an overlapping block move
  67.      *    goto 1
  68.      */
  69. void Epack_keytable(kt,remove_key) dTable *kt; int (*remove_key)();
  70. {
  71.   register char *ptr, *key;
  72.   register int keysize, k,n;
  73.  
  74.   n = sizeof_dTable(kt); key = kt->table; keysize = kt->blob_size;
  75.   for (k = 0; n--; key += keysize, k++)
  76.     if ((*remove_key)(key))
  77.     {
  78.       for (ptr = key, key += keysize; n--; key += keysize)
  79.     if (!(*remove_key)(key))
  80.         { memcpy(ptr,key,keysize); ptr += keysize; k++; }
  81.       sizeof_dTable(kt) = k;
  82.       break;
  83.     }
  84. }
  85.  
  86. static KeyCode zap_keycode;        /* a bit of ugliness here */
  87. static int zap_key(key) char *key;
  88.     { return *(KeyCode *)key == zap_keycode; }
  89.  
  90. void Eunbind_key(kt,keycode) dTable *kt; KeyCode keycode;
  91. {
  92.   zap_keycode = keycode;
  93.   Epack_keytable(kt,zap_key);
  94. }
  95.